import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 幻影坦克图片生成器
 * 生成在白色和黑色背景下显示不同图像的PNG图片
 */
public class PhantomTankGenerator {

    /**
     * 生成幻影坦克图片
     *
     * @param whiteBgImage 白色背景下显示的图像（推荐深色主体）
     * @param blackBgImage 黑色背景下显示的图像（推荐浅色主体）
     * @return 生成的PNG图片字节数组
     * @throws IOException 图像处理异常
     */
    public static byte[] generate(BufferedImage whiteBgImage, BufferedImage blackBgImage) throws IOException {
        // 统一图像尺寸
        int width = Math.min(whiteBgImage.getWidth(), blackBgImage.getWidth());
        int height = Math.min(whiteBgImage.getHeight(), blackBgImage.getHeight());

        // 创建输出图像（RGBA格式）
        BufferedImage result = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);

        // 逐像素处理
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                // 获取两张图像的RGB值
                int rgbW = whiteBgImage.getRGB(x, y);
                int rgbB = blackBgImage.getRGB(x, y);

                // 分解RGB通道
                int rW = (rgbW >> 16) & 0xFF;
                int gW = (rgbW >> 8) & 0xFF;
                int bW = rgbW & 0xFF;

                int rB = (rgbB >> 16) & 0xFF;
                int gB = (rgbB >> 8) & 0xFF;
                int bB = rgbB & 0xFF;

                // 预处理：确保满足 r2 ≥ r1 的条件
                rW /= 2;
                gW /= 2;
                bW /= 2;

                rB = rB / 2 + 128;
                gB = gB / 2 + 128;
                bB = bB / 2 + 128;

                // 计算Alpha通道和RGB值
                float alphaR = 1 + (rW - rB) / 255f;
                alphaR = Math.max(0, Math.min(1, alphaR));
                int r = (int) Math.max(0, Math.min(255, rW / alphaR));

                float alphaG = 1 + (gW - gB) / 255f;
                alphaG = Math.max(0, Math.min(1, alphaG));
                int g = (int) Math.max(0, Math.min(255, gW / alphaG));

                float alphaB = 1 + (bW - bB) / 255f;
                alphaB = Math.max(0, Math.min(1, alphaB));
                int b = (int) Math.max(0, Math.min(255, bW / alphaB));

                // 合并Alpha通道（取平均值）
                int alpha = (int) (((alphaR + alphaG + alphaB) / 3) * 255);

                // 组合ARGB值
                int argb = (alpha << 24) | (r << 16) | (g << 8) | b;
                result.setRGB(x, y, argb);
            }
        }

        // 转换为PNG字节数组
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            ImageIO.write(result, "PNG", baos);
            return baos.toByteArray();
        }
    }

    /**
     * 从字节数组创建BufferedImage
     *
     * @param imageData 图像字节数组
     * @return BufferedImage对象
     * @throws IOException 图像解析异常
     */
    public static BufferedImage createImageFromBytes(byte[] imageData) throws IOException {
        try (InputStream is = new ByteArrayInputStream(imageData)) {
            return ImageIO.read(is);
        }
    }
}